let script = document.createElement("script");
script.type = "text/javascript";
script.src = "/resources/js/axios.js";
document.getElementsByTagName('head')[0].appendChild(script);

/**
 * 封装AJAX Post请求
 * 增加请求头X-Requested-With，以便标识为Ajax请求；对后端拦截的响应做统一处理
 * 默认返回结果结构：{data:{flag, data, errorMsg}}
 *
 * @param url 请求地址
 * @param data 数据
 * @param successCallback 执行成功的回调方法，参数returnData为后台返回数据
 * @param failCallback 执行失败的回调方法，参数returnData为后台返回数据
 * @param errorCallback 出错的回调方法，参数error为异常数据
 *
 * @return {boolean} 执行成功回调后，返回true，其他均返回false
 */
function ajaxPostPackage(url, data, successCallback, failCallback, errorCallback) {
    return axios.post(url, data, {headers: {'X-Requested-With': 'XMLHttpRequest'}})
        .then(result => {
            let returnData = result.data;
            if(returnData.flag){
                successCallback(returnData);
                return true;
            }else{
                failCallback(returnData);
                return false;
            }
        })
        .catch(error => {
            //获取响应头
            let response = error.response;
            if (typeof(response) != "undefined") {
                let headers = response.headers;
                //获取转发标志和转发地址
                let redirect = headers.redirect;
                let contentPath = decodeURIComponent(headers['contentpath']);
                //跳转至服务器指定的路径
                if (redirect == "REDIRECT") {
                    window.top.location.href = contentPath;
                    return false;
                }
            }
            errorCallback(error);
            return false;
        });
};

/**
 * 封装AJAX Get请求
 * 增加请求头X-Requested-With，以便标识为Ajax请求；对后端拦截的响应做统一处理
 * 默认返回结果结构：{data:{flag, data, errorMsg}}
 *
 * @param url 请求地址
 * @param successCallback 执行成功的回调方法，参数returnData为后台返回数据
 * @param failCallback 执行失败的回调方法，参数returnData为后台返回数据
 * @param errorCallback 出错的回调方法，参数error为异常数据
 *
 * @return {boolean} 执行成功回调后，返回true，其他均返回false
 */
function ajaxGetPackage(url, successCallback, failCallback, errorCallback) {
    return axios.get(url, {headers: {'X-Requested-With': 'XMLHttpRequest'}})
        .then(result => {
            let returnData = result.data;
            if(returnData.flag){
                successCallback(returnData);
                return true;
            }else{
                failCallback(returnData);
                return false;
            }
        })
        .catch(error => {
            //获取响应头
            let response = error.response;
            if (typeof(response) != "undefined") {
                let headers = response.headers;
                //获取转发标志和转发地址
                let redirect = headers.redirect;
                let contentPath = decodeURIComponent(headers['contentpath']);
                //跳转至服务器指定的路径
                if (redirect == "REDIRECT") {
                    window.top.location.href = contentPath;
                    return false;
                }
            }
            errorCallback(error);
            return false;
        });
};

/**
 * 日期格式化
 * 调用：new Date().dateFormatString(格式化字符串)
 *
 * @param dataFormat 格式化字符串：y年，M月份，d日，H小时，m分钟，s秒，S毫秒，例如yyyyMMdd HH:mm:ss:S
 *
 * @returns {string} 格式化后的日期字符串
 */
Date.prototype.dateFormatString = function (dataFormat) {
    //格式化的每个字段
    let formatRegular = {
        //月份
        "M+": this.getMonth() + 1,
        //日
        "d+": this.getDate(),
        //小时
        "H+": this.getHours(),
        //分
        "m+": this.getMinutes(),
        //秒
        "s+": this.getSeconds(),
        //毫秒
        "S": this.getMilliseconds()
    };
    //格式化年份
    if (/(y+)/.test(dataFormat)) {
        dataFormat = dataFormat.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    }
    //格式化其他字段
    for (let node in formatRegular) {
        if (new RegExp("(" + node + ")").test(dataFormat)) {
            dataFormat = dataFormat.replace(RegExp.$1, (RegExp.$1.length == 1) ? (formatRegular[node]) : (("00" + formatRegular[node]).substr(("" + formatRegular[node]).length)));
        }
    }
    return dataFormat;
};

/**
 * 删除数组指定元素
 * @param node 要删除的元素
 * @returns {boolean} 删除成功，返回true
 */
Array.prototype.remove = function (node) {
    let index = this.indexOf(node);
    if (index > -1) {
        this.splice(index, 1);
        return true;
    } else {
        return false;
    }
}

/**
 * 数组不影响原数组的排序
 * @returns {null|*[]|{}}
 */
Array.prototype.sortNoAffect = function () {
    let sortArray = clone(this);
    sortArray.sort();
    return sortArray;
}

/**
 * 克隆对象，防止引用类型变量赋值后会与原对象共用一个地址
 * @param objectParam 要克隆的对象
 * @returns {null|[]|{}} 返回克隆后的数组、对象，传入空值，则返回空
 */
function clone (objectParam) {
    let nodeObject;
    if (typeof objectParam == "object") {
        if (objectParam === null) {
            nodeObject = null;
        } else {
            if (objectParam instanceof Array) {
                nodeObject = [];
                for (let i = 0, len = objectParam.length; i < len; i++) {
                    nodeObject.push(clone(objectParam[i]));
                }
            } else {
                nodeObject = {};
                for (let subNode in objectParam) {
                    nodeObject[subNode] = clone(objectParam[subNode]);
                }
            }
        }
    } else {
        nodeObject = objectParam;
    }
    return nodeObject;
}